package com.paw.ruoyi.admin.core.util;

import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.StringRedisTemplate;


public class StringRedisUtilService {

  private StringRedisTemplate redisTemplate;

  public StringRedisUtilService(StringRedisTemplate redisTemplate){
    this.redisTemplate = redisTemplate;
  }


  // *********************************************** key相关操作 start

  /**
   * 删除key
   */
  public void delete(String key) {
    redisTemplate.delete(key);
  }

  /**
   * 批量删除key
   */
  public void delete(Collection<String> keys) {
    redisTemplate.delete(keys);
  }

  /**
   * 序列化key
   */
  public byte[] dump(String key) {
    return redisTemplate.dump(key);
  }

  /**
   * 是否存在key
   */
  public Boolean hasKey(String key) {
    return redisTemplate.hasKey(key);
  }

  /**
   * 设置过期时间
   */
  public Boolean expire(String key, long timeout, TimeUnit unit) {
    return redisTemplate.expire(key, timeout, unit);
  }

  /**
   * 设置过期时间
   */
  public Boolean expireAt(String key, Date date) {
    return redisTemplate.expireAt(key, date);
  }

  /**
   * 查找匹配的key
   */
  public Set<String> keys(String pattern) {
    return redisTemplate.keys(pattern);
  }

  /**
   * 将当前数据库的 key 移动到给定的数据库 db 当中
   */
  public Boolean move(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
  }

  /**
   * 移除 key 的过期时间，key 将持久保持
   */
  public Boolean persist(String key) {
    return redisTemplate.persist(key);
  }

  /**
   * 返回 key 的剩余的过期时间
   */
  public Long getExpire(String key, TimeUnit unit) {
    return redisTemplate.getExpire(key, unit);
  }

  /**
   * 返回 key 的剩余的过期时间
   */
  public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
  }

  /**
   * 从当前数据库中随机返回一个 key
   */
  public String randomKey() {
    return redisTemplate.randomKey();
  }

  /**
   * 修改 key 的名称
   */
  public void rename(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
  }

  /**
   * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
   */
  public Boolean renameIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
  }

  /**
   * 返回 key 所储存的值的类型
   */
  public DataType type(String key) {
    return redisTemplate.type(key);
  }

  //*************************************************string相关操作

  /**
   * 设置指定 key 的值
   */
  public void set(String key, String value) {
    redisTemplate.opsForValue().set(key, value);
  }

  /**
   * 设置指定值
   * @param key
   * @param value
   * @param time 过期时间
   * @param timeUnit  单位
   */
  public void setExpre(String key, String value, long time, TimeUnit timeUnit) {
    redisTemplate.opsForValue().set(key, value,time, timeUnit);
  }

  /**
   * 获取指定 key 的值
   */
  public String get(String key) {
    return redisTemplate.opsForValue().get(key);
  }

  /**
   * 返回 key 中字符串值的子字符
   */
  public String getRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
  }

  /**
   * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
   */
  public String getAndSet(String key, String value) {
    return redisTemplate.opsForValue().getAndSet(key, value);
  }

  /**
   * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
   */
  public Boolean getBit(String key, long offset) {
    return redisTemplate.opsForValue().getBit(key, offset);
  }

  /**
   * 批量获取
   */
  public List<String> multiGet(Collection<String> keys) {
    return redisTemplate.opsForValue().multiGet(keys);
  }

  /**
   * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
   */
  public boolean setBit(String key, long offset, boolean value) {
    return redisTemplate.opsForValue().setBit(key, offset, value);
  }

  /**
   * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
   */
  public void setEx(String key, String value, long timeout, TimeUnit unit) {
    redisTemplate.opsForValue().set(key, value, timeout, unit);
  }

  /**
   * 只有在 key 不存在时设置 key 的值
   */
  public boolean setIfAbsent(String key, String value) {
    return redisTemplate.opsForValue().setIfAbsent(key, value);
  }

  /**
   * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
   */
  public void setRange(String key, String value, long offset) {
    redisTemplate.opsForValue().set(key, value, offset);
  }

  /**
   * 获取字符串的长度
   */
  public Long size(String key) {
    return redisTemplate.opsForValue().size(key);
  }

  /**
   * 批量添加
   */
  public void multiSet(Map<String, String> maps) {
    redisTemplate.opsForValue().multiSet(maps);
  }

  /**
   * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
   */
  public boolean multiSetIfAbsent(Map<String, String> maps) {
    return redisTemplate.opsForValue().multiSetIfAbsent(maps);
  }

  /**
   * 增加(自增长), 负数则为自减
   */
  public Long incrBy(String key, long increment) {
    return redisTemplate.opsForValue().increment(key, increment);
  }

  /**
   * 增加(自增长), 负数则为自减  浮点数
   */
  public Double incrByFloat(String key, double increment) {
    return redisTemplate.opsForValue().increment(key, increment);
  }

  /**
   * 追加到末尾
   */
  public Integer append(String key, String value) {
    return redisTemplate.opsForValue().append(key, value);
  }


}
